function formatTime(time) {
	if (typeof time !== 'number' || time < 0) {
		return time
	}

	var hour = parseInt(time / 3600)
	time = time % 3600
	var minute = parseInt(time / 60)
	time = time % 60
	var second = time

	return ([hour, minute, second]).map(function(n) {
		n = n.toString()
		return n[1] ? n : '0' + n
	}).join(':')
}

function formatLocation(longitude, latitude) {
	if (typeof longitude === 'string' && typeof latitude === 'string') {
		longitude = parseFloat(longitude)
		latitude = parseFloat(latitude)
	}

	longitude = longitude.toFixed(2)
	latitude = latitude.toFixed(2)

	return {
		longitude: longitude.toString().split('.'),
		latitude: latitude.toString().split('.')
	}
}

///////////////////////////
//检验运算公式
function validatedFunc(formula) {
	  const re = /[^a-z0-9\(\)\+\-\×\÷\.]{1,}/ // 判断输入字符合法性的正则(只能输入数字,+-×÷,(),#{})
	  const ru = /#\{(.+?)\}/g // 取出#{}中的字符正则
	  const regex1 = /\((.+?)\)/g // 匹配出所有括号,返回数组
	  // 剔除空白符
	  formula = formula.replace(/\s/g, '')
	  
	  // 如果输入了不合法的字符,直接返回不合法(除去#{}中的内容)
	  const str = formula.replace(/#\{(.+?)\}/g, '')
	 
	  let result = false
	  result = re.test(str)
	  if (result) return '请选择系统提供的字段和运算符';
	  // 空括号
	  if (/\(\)/.test(formula)) return '括号中至少维护一个运算公式';
	  const left = [] // 遇到左括号存入数量和索引
	  const right = [] // 遇到右括号存入数量和索引
	  let lnum = 1 // 记录左括号的数量
	  let rnum = 1 // 记录右括号的数量
	  const str2 = formula.split('') // 将字符串转为数组
	  // 判断括号相关
	  // 括号不配对
	  const stack = []
	  for (var q = 0, item; q < formula.length; q++) {
	    item = formula.charAt(q)
	    if (item === '(') {
	      stack.push('(')
	    } else if (item === ')') {
	      if (stack.length > 0) {
	        stack.pop()
	      } else {
	       return "括号必须成对出现111";return;
	      }
	    }
	  }
	  //return stack.length);
	  if (stack.length !== 0)return '括号必须成对出现';

	  var Pj;

	  for (let iii = 0; iii < str2.length; iii++) {

	  	if(str2[iii] == Pj && (str2[iii] == '.' || str2[iii] == '×' || str2[iii] == '÷' || str2[iii] == '-' || str2[iii] == '+')){
	  		return '公式不合法';
	  	}

	    if (str2[iii] == '(') { // 循环遇到左括号
	      left.push({ num: lnum++, index: iii }) // 存入数量和索引
	    } else if (str2[iii] == ')') { // 循环遇到右括号
	      right.push({ num: rnum++, index: iii }) // 存入数量和索引
	      // if(lnum != rnum){
	      // 	console.log('没有括号')
	      // }
	      const xyz = str2.slice(left[left.length - 1].index, right[right.length - 1].index + 1) // 取出遇到右括号时与上一个左括号之间的内容
	      // 校验xyz
	      // 判断括号中是否包含＋- × ÷
	      const b = xyz.join('').match(regex1) // 将数组转回字符串进行取括号中的内容
	      if (b) {
	        // 判断字符串中是否有括号
	        for (let i = 0; i < b.length; i++) {
	          if (b[i].match(/×|-|[÷]|[+]/)) {
	            // 匹配加减乘除
	            //return '有加减乘除')
	          } else {
	            //return '没有加减乘除')
	           return '括号中至少维护一个运算公式';
	          }
	        }
	      } else {
	        return '没有括号';
	      }
	      // 删除匹配完后两个位置的括号,替换成空格
	      str2.splice(left[left.length - 1].index, 1, ' ')
	      str2.splice(right[right.length - 1].index, 1, ' ')
	      // 删除数组中最后一项,继续匹配
	      left.pop()
	      right.pop()
	    }
	    Pj = str2[iii];
	  }
	  // 判断数字相关
	  // 错误情况，.后面不是数字
	  if (/\.[^0-9]/.test(formula))return '公式不合法';
	  // 错误情况，.前面不是数字
	  if (/[^0-9]\./.test(formula))return '公式不合法';
	  // 判断数字是否超过10位,小数点是否超过两位
	  const arrNum = []
	  let tmp = ''
	  for (var i = 0; i < formula.length; i++) {
	    if (
	      (formula.charAt(i) <= '9' && formula.charAt(i) >= '0') ||
	      formula.charAt(i) == '.'
	    ) {
	      tmp += formula.charAt(i)
	    } else {
	      if (tmp) {
	        arrNum.push(tmp)
	        tmp = ''
	      }
	    }
	  } // 在循环外加一个判断，是因为当字符串遍历到最后一位9的时候，不会走else里面的内容，无法加到数组
	  if (tmp) {
	    arrNum.push(tmp)
	    tmp = ''
	  }
	  arrNum.forEach((item) => {
	    if (parseInt(item) > 999999999)return '最大不超过十位数';
	    if (item.split('.')[1] && item.split('.')[1].length > 3) {return '最多输入三位小数'; }
	  })
	  

	  // 错误情况，( 后面是运算符
	  if (/\([\+\-\×\÷]/.test(formula)) {return '运算公式配置不正确'; }

	  if (/\([\+\-\×\÷]/.test(formula)) {return '运算公式配置不正确'; }

	  // 错误情况，) 前面是运算符
	  if (/[\+\-\×\÷]\)/.test(formula)) {return '运算公式配置不正确'; }
	  // 错误情况，( 前面不是运算符 或 空
	  if (/[^\+\-\×\÷\(\s]\(/.test(formula)) {return '运算公式配置不正确'; }
	  // 错误情况，) 后面不是运算符 或 空
	  if (/\)[^\+\-\×\÷\)\s]/.test(formula)) {return '运算公式配置不正确'; }
	  // 错误情况，运算符号不能在首末位
	  if (/^[\+\-\×\÷.]|[\+\-\×\÷.]$/.test(formula)) {return '运算公式配置不正确'; }
	  // 错误情况，运算符连续
	  if (/[\+\-\*\/]{2,}/.test(formula)) {return '运算公式配置不正确'; }
	  // 错误情况，#{}后面不是 运算符或 ) 或 ''
	  //return /#\{.+\}[^\+\-\×\÷]/.test(formula), '.......................';
	  if (/#\{.+\}[^\+\-\×\÷\)\s]/.test(formula))return '运算公式配置不正确';
	  // 错误情况，#{}前面不是 运算符或 ( 或 ''
	  if (/[^\+\-\×\÷\(\s]#\{.+\}/.test(formula))return '运算公式配置不正确';
	  // 判断不是系统提供的字段(#{}包含的内容)
	  const e = formula.match(ru)
	  if (e) {
	    e.forEach(item => {
	      const o = item.match(/#\{(.+)\}/)[1];
	      //return item.match(/#\{(.+)\}/)[1])
	      // const dd = ruleArr.filter(val => o == val.ruleName)
	      // //return dd, 'dddddddddddddddddddd';
	      // if (!dd.length)return '请选择系统提供的字段';
	    })
	  }
	  return true
}

function sliceCountStr(str) {
	  let arr = []; // 记录分割计算表达式
	  for (let i = 0; i < str.length; i++) {
		let item = str.charAt(i);
		let num = item;
		if (/[\d]/.test(item)) {
		  let j = i + 1;
		  for (; j < str.length - 1; j++) {
			let otherItem = str.charAt(j);
			if (!/[\d]/.test(otherItem)) {
			  break;
			}
		  }
		  num = str.slice(i, j);
		  i = j - 1;
		  num = +num;
		}
		arr.push(num);
	  }
	  return arr;
}

//
function countHandle(arr) {
	  let charArr = [],
		numArr = [];
	  for (let i = 0; i < arr.length; i++) {
		if (typeof arr[i] == 'number') {
		  numArr.push(arr[i]);
		} else {
		  if (charArr.length) {
			// 步骤1
			// 如果当前的运算符的优先级比栈顶的优先级低或相等，就说明需要把前面的值全部计算好
			// 存储运算符的栈要一直出栈，直到栈为空或当前的字符的优先级比栈顶的优先级高
			while (isPop(arr[i], charArr[charArr.length - 1])) {
			  let t2 = numArr.pop();
			  let t1 = numArr.pop();
			  let char = charArr.pop();
			  handleCalculation(numArr, t1, t2, char);
			}
			// 当前运算符为右括号
			if (arr[i] == ')') {
			  // 取栈顶运算符
			  let st = charArr[charArr.length - 1];
			  // 步骤2
			  // 遇到右括号也要一直出栈，直到遇到左括号
			  while (st != '(') {
				let t1, t2;
				let char = charArr.pop();
				if (char != '(') {
				  t2 = numArr.pop();
				  t1 = numArr.pop();
				  handleCalculation(numArr, t1, t2, char);
				}
				st = char;
			  }
			}
			// 运算符不为右括号
			if (arr[i] != ')') {
			  charArr.push(arr[i]);
			}
		  } else {
			// 步骤3
			// 运算符栈为空，直接入栈
			charArr.push(arr[i]);
		  }
		}
	  }
	  // 步骤4
	  // 最后运算符栈如果还有字符，要一直出栈直到为空
	  while (charArr.length) {
		let t2 = numArr.pop();
		let t1 = numArr.pop();
		let char = charArr.pop();
		handleCalculation(numArr, t1, t2, char);
	  }
	  return numArr[0];
}

// 基本加减乘除运算处理
function handleCalculation(numArr, num1, num2, char) {
  if (char == '+') {
	numArr.push(num1 + num2);
  } else if (char == '-') {
	numArr.push(num1 - num2);
  } else if (char == '×') {
	numArr.push(num1 * num2);
  } else if (char == '÷') {
	numArr.push(num1 / num2);
  }
}

// 判断运算符的优先级，是否出栈进行计算
function isPop(char1, char2) {
  // 运算符栈为空
  if (!char2) {
	return false;
  }
  // 运算符优先级相同
  if ((char1 == '+' || char1 == '-') && (char2 == '+' || char2 == '-')) {
	return true;
  }
  // 前者运算符优先级比后者低
  if ((char1 == '+' || char1 == '-') && (char2 == '×' || char2 == '÷')) {
	return true;
  }
  // 运算符优先级相同
  if ((char1 == '×' || char1 == '÷') && (char2 == '×' || char2 == '÷')) {
	return true;
  }
  // 前者运算符优先级比后者高
  if ((char1 == '×' || char1 == '÷') && (char2 == '+' || char2 == '-')) {
	return false;
  }
}


//字符串替换
function strReplace(str){
	var newstr = str.replace(/width/g,"宽");
	var newstr = newstr.replace(/length/g,"长");
	var newstr = newstr.replace(/height/g,"高");
	var newstr = newstr.replace(/profit/g,"利润率");
	var newstr = newstr.replace(/price/g,"来价");
	var newstr = newstr.replace(/\*/g,"×");
	var newstr = newstr.replace(/\//g,"÷");
	return newstr;
}

function restrReplace(str){
	var newstr = str.replace(/宽/g,"width");
	var newstr = newstr.replace(/长/g,"length");
	var newstr = newstr.replace(/高/g,"height");
	var newstr = newstr.replace(/利润率/g,"profit");
	var newstr = newstr.replace(/来价/g,"price");
	var newstr = newstr.replace(/×/g,"*");
	var newstr = newstr.replace(/÷/g,"/");
	return newstr;
}
//////////////////////////
//排序
function sortReplace(pargm){
	
	//排序
	pargm.sort(function(a, b) {
	    // 比较A值
	    if (a.is_top != b.is_top) {
	     return a.is_top > b.is_top ? -1 : 1;
	      // return b.is_top - a.is_top;
	    }
	    // // 如果A值相同，比较B值
	    // return b.updated_at - a.updated_at;
	    return a.updated_at > b.updated_at ? -1 : 1;
	});
	
	let newformula = [];
	
	pargm.forEach((i,index)=>{
		let formulaArr = [];
		formulaArr.id = i.private_formula_id;
		formulaArr.name = i.name;
		formulaArr.is_top = i.is_top;
		formulaArr.formula_len = strReplace(i.formula_len);
		formulaArr.formula_degree = strReplace(i.formula_degree);
		formulaArr.oldformula = i.formula;
		formulaArr.user_id = i.user_id;
		//字符替换
		var newformulastr = strReplace(i.formula);
		
		formulaArr.formula = newformulastr;
		newformula.push(formulaArr);
		
	})
	return newformula;
	// this.newformulaArr = a;
	// this.newformula_lenArr = newformula_lenArr;
	// this.newformula_degreeArr = newformula_degreeArr;
	// this.skillsRange = newformula;
}

//模糊查询
// function serchAll(array, searchTerm, key){
// 	return array.filter(obj =>
// 	  String(obj[key]).toLowerCase().includes(searchTerm.toLowerCase())
// 	);
// }
function fuzzySearchObjects(array, searchTerm, key) {
  
}
var dateUtils = {
	UNITS: {
		'年': 31557600000,
		'月': 2629800000,
		'天': 86400000,
		'小时': 3600000,
		'分钟': 60000,
		'秒': 1000
	},
	humanize: function(milliseconds) {
		var humanize = '';
		for (var key in this.UNITS) {
			if (milliseconds >= this.UNITS[key]) {
				humanize = Math.floor(milliseconds / this.UNITS[key]) + key + '前';
				break;
			}
		}
		return humanize || '刚刚';
	},
	format: function(dateStr) {
		var date = this.parse(dateStr)
		var diff = Date.now() - date.getTime();
		if (diff < this.UNITS['天']) {
			return this.humanize(diff);
		}
		var _format = function(number) {
			return (number < 10 ? ('0' + number) : number);
		};
		return date.getFullYear() + '/' + _format(date.getMonth() + 1) + '/' + _format(date.getDate()) + '-' +
			_format(date.getHours()) + ':' + _format(date.getMinutes());
	},
	parse: function(str) { //将"yyyy-mm-dd HH:MM:ss"格式的字符串，转化为一个Date对象
		var a = str.split(/[^0-9]/);
		return new Date(a[0], a[1] - 1, a[2], a[3], a[4], a[5]);
	}
};

export {
	formatTime,
	formatLocation,
	dateUtils,
	validatedFunc,
	sliceCountStr,
	countHandle,
	strReplace,
	restrReplace,
	sortReplace,
}
